package action;

import constantes.Constantes;
import ejb.AdministrarHistoriaBean;
import entidades.TAdicion;
import entidades.TAfinacion;
import entidades.TAgudezaVisual;
import entidades.TCatalogoMedicamento;
import entidades.TControl;
import entidades.TDiagnostico;
import entidades.TDiagnosticoManejo;
import entidades.TExamenMotor;
import entidades.TLensometria;
import entidades.TMedicamento;
import entidades.TMicroscopia;
import entidades.TOftalmoscopia;
import entidades.TPatologia;
import entidades.TPersona;
import entidades.TPrescripcion;
import entidades.TPrescripcionLentesContacto;
import entidades.TPrescripcionMedica;
import entidades.TProfesional;
import entidades.TQueratometria;
import entidades.TRefraccion;
import entidades.TSubjetivo;
import entidades.TTipLente;
import entidades.TTipOptotipo;
import entidades.TTipoMaterial;
import enumeraciones.AcomodativoEnum;
import enumeraciones.AnguloKappaEnum;
import enumeraciones.BrucknerEnum;
import enumeraciones.CantidadEnum;
import enumeraciones.DistanciaEnum;
import enumeraciones.DistanciaNasoPupilarEnum;
import enumeraciones.DistanciaPupilarEnum;
import enumeraciones.DominanteEnum;
import enumeraciones.DuccionesEnum;
import enumeraciones.EjeEnum;
import enumeraciones.EquipoEnum;
import enumeraciones.EsferaCilindroEnum;
import enumeraciones.ExamenApoyoEnum;
import enumeraciones.FiltroEnum;
import enumeraciones.ManoDominanteEnum;
import enumeraciones.MedioRefractanteEnum;
import enumeraciones.MiraEnum;
import enumeraciones.MusculoEnum;
import enumeraciones.MusculoVersionesEnum;
import enumeraciones.NombreComercialEnum;
import enumeraciones.ObjetoLuzEnum;
import enumeraciones.OjoEnum;
import enumeraciones.PresentacionEnum;
import enumeraciones.ReemplazoEnum;
import enumeraciones.RemisionEnum;
import enumeraciones.SistemaLimpiezaEnum;
import enumeraciones.SubTipoOptoTipoEnum;
import enumeraciones.TecnicaEnum;
import enumeraciones.TecnicaPeliculaLagrimalEnum;
import enumeraciones.TecnicaPoloPosteriorEnum;
import enumeraciones.TecnicaTincionConjuntivalEnum;
import enumeraciones.TestAcomodacionMotoraEnum;
import enumeraciones.TincionCornealEnum;
import enumeraciones.TipoGlandulaEnum;
import enumeraciones.TipoLenteContactoEnum;
import enumeraciones.TipoMedicamentoEnum;
import enumeraciones.TipoRefraccionEnum;
import enumeraciones.TonometroEnum;
import enumeraciones.UsoEnum;
import enumeraciones.UsoLenteContactoEnum;
import enumeraciones.VanHerickEnum;
import enumeraciones.VersionEnum;
import enumeraciones.VisionLejanaEnum;
import java.io.Serializable;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import javax.ejb.EJB;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.SessionScoped;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.validator.ValidatorException;
import org.primefaces.event.RowEditEvent;
import utils.ControlDTO;
import utils.ListasUtils;
import utils.MensajeUtils;

@ManagedBean(name = "administrarControlAction")
@SessionScoped
public class AdministrarControlAction implements Serializable {

    private final String INFORMACION = MensajeUtils.getMensaje("informacion");
    private final String ADVERTENCIA = MensajeUtils.getMensaje("advertencia");
    private final String ERROR = MensajeUtils.getMensaje("error");
    private FacesMessage msg;
    @EJB
    AdministrarHistoriaBean administrarHistoriasClinicasBean;

    List<TControl> listaControl = new ArrayList<TControl>();
    TPersona persona;
    TProfesional profesional = new TProfesional();

    Date fechaInicial;
    Date fechaFinal;
    SimpleDateFormat formatHora = new SimpleDateFormat("hh:mm");

    TControl controlCrear;

    ControlDTO controlDTO;

    private TAgudezaVisual agudezaVisual;
    private List<TTipOptotipo> listaOptotiposVP;
    private List<TTipOptotipo> listaOptotiposVL;
    private List<DistanciaEnum> listaDistancias = Arrays.asList(DistanciaEnum.values());

    private TLensometria lensometria;
    private List<EsferaCilindroEnum> listaEsferaCilindro = Arrays.asList(EsferaCilindroEnum.values());
    private List<EjeEnum> listaEje = Arrays.asList(EjeEnum.values());

    private List<TTipLente> listaTipoLentes;
    private List<TTipoMaterial> listaTipoMateriales;

    private TPrescripcion prescripcion;
    private List<UsoEnum> listaUsos = Arrays.asList(UsoEnum.values());

    private TPrescripcionLentesContacto prescripcionLentes;
    private List<TipoLenteContactoEnum> listaLentesContacto = Arrays.asList(TipoLenteContactoEnum.values());
    private List<NombreComercialEnum> listaNombreComercial = Arrays.asList(NombreComercialEnum.values());
    private List<UsoLenteContactoEnum> listaUsoLentesConstacto = Arrays.asList(UsoLenteContactoEnum.values());
    private List<ReemplazoEnum> listaReemplazo = Arrays.asList(ReemplazoEnum.values());
    private List<SistemaLimpiezaEnum> listaSistemaLimpieza = Arrays.asList(SistemaLimpiezaEnum.values());

    private TPrescripcionMedica prescripcionMedica;
    private List<TCatalogoMedicamento> listaMedicamentos;
    private List<TCatalogoMedicamento> listaMedicamentosResult;
    private List<TMedicamento> listaMedicamentosSelected;
    private TCatalogoMedicamento medicamentoSearch;
    private List<TipoMedicamentoEnum> listaTipoMedicamento = Arrays.asList(TipoMedicamentoEnum.values());
    private List<String> listaGenericos;
    private List<PresentacionEnum> listaPresentaciones = Arrays.asList(PresentacionEnum.values());
    private List<String> listaNombresComerciales;

    private TOftalmoscopia oftalmoscopia;
    private List<OjoEnum> listaMedioRefraccion = Arrays.asList(OjoEnum.values());
    private List<TecnicaEnum> listaTecnicas = Arrays.asList(TecnicaEnum.values());
    private List<BrucknerEnum> listaBruckner = Arrays.asList(BrucknerEnum.values());
    private List<MedioRefractanteEnum> listaMedioRefractante = Arrays.asList(MedioRefractanteEnum.values());

    private TQueratometria queratometria;
    private List<CantidadEnum> listaCantidades = Arrays.asList(CantidadEnum.values());
    private List<EquipoEnum> listaEquipos = Arrays.asList(EquipoEnum.values());
    private List<MiraEnum> listaMiras = Arrays.asList(MiraEnum.values());

    private TRefraccion refraccion;
    private List<TipoRefraccionEnum> listaTipoRefraccion = Arrays.asList(TipoRefraccionEnum.values());

    private TSubjetivo subjetivo;
    private TAfinacion afinacion;
    private TAdicion adicion;

    private TDiagnosticoManejo diagnosticoManejo;
    private List<TDiagnostico> listaDiagnosticos;
    private List<RemisionEnum> listaRemision = Arrays.asList(RemisionEnum.values());
    private List<ExamenApoyoEnum> listaExamenApoyo = Arrays.asList(ExamenApoyoEnum.values());

    private TExamenMotor examenMotor;
    private List<AcomodativoEnum> listaAcomodativos = Arrays.asList(AcomodativoEnum.values());
    private List<TestAcomodacionMotoraEnum> listaTests = Arrays.asList(TestAcomodacionMotoraEnum.values());
    private List<VisionLejanaEnum> listaVisionLejana = Arrays.asList(VisionLejanaEnum.values());
    private List<MusculoEnum> listaMusculos = Arrays.asList(MusculoEnum.values());
    private List<MusculoVersionesEnum> listaMusculoVersion = Arrays.asList(MusculoVersionesEnum.values());
    private List<ObjetoLuzEnum> listaObjetoLuz = Arrays.asList(ObjetoLuzEnum.values());
    private List<VersionEnum> listaVersiones = Arrays.asList(VersionEnum.values());
    private List<DominanteEnum> listaDominantes = Arrays.asList(DominanteEnum.values());
    private List<ManoDominanteEnum> listaManoDominante = Arrays.asList(ManoDominanteEnum.values());
    private List<AnguloKappaEnum> listaAnguloKappa = Arrays.asList(AnguloKappaEnum.values());
    private List<DuccionesEnum> listaDucciones = Arrays.asList(DuccionesEnum.values());

    private TMicroscopia biomicrospia;
    private List<TincionCornealEnum> listaTincionCorneal = Arrays.asList(TincionCornealEnum.values());
    private List<TonometroEnum> listaTonometros = Arrays.asList(TonometroEnum.values());
    private List<TipoGlandulaEnum> listaTipoGlandula = Arrays.asList(TipoGlandulaEnum.values());
    private List<TPatologia> listaPatologias;
    private List<TecnicaPeliculaLagrimalEnum> listaPeliculaLagrimal = Arrays.asList(TecnicaPeliculaLagrimalEnum.values());
    private List<TecnicaPoloPosteriorEnum> listaPoloPosterior = Arrays.asList(TecnicaPoloPosteriorEnum.values());
    private List<TecnicaTincionConjuntivalEnum> listaTincionConjuntival = Arrays.asList(TecnicaTincionConjuntivalEnum.values());
    private List<FiltroEnum> listaFiltros = Arrays.asList(FiltroEnum.values());
    private List<DistanciaPupilarEnum> listaDistPupilar = Arrays.asList(DistanciaPupilarEnum.values());
    private List<DistanciaNasoPupilarEnum> listaDistNasoPupilar = Arrays.asList(DistanciaNasoPupilarEnum.values());
    private List<VanHerickEnum> listaVanHerick = Arrays.asList(VanHerickEnum.values());

    private boolean editingOjoDerecho;
    private String tituloCanvas;
    /**
     * Variable utilizada para controlar el tab activo cuando se regresa de la
     * edicion de un ojo
     */
    private int selectedTab;

    //@ManagedProperty(value="#{administrarLoginAction}" )
    //AdministrarLoginAction administrarLoginAction;
    /**
     * Metodo llamado desde el form de gestionar personas
     *
     * @param persona
     * @return regla de navegacion
     */
    public String iniciarControl(TPersona persona) {
        if (this.persona != null) {
            return "";
        }
        this.persona = persona;
        TProfesional user = new TProfesional();
        user.setUserName("javier.rey");
        //this.profesional = administrarLoginAction.getUser();
        this.profesional = user;
        fechaFinal = null;
        fechaInicial = null;
        controlCrear = null;
        buscarControl();
        return "gestionar_control?faces-redirect=true";
    }

    public void buscarControl() {
        controlDTO = new ControlDTO();
        controlDTO.setFechaFinal(fechaFinal);
        controlDTO.setFechaInicial(fechaInicial);
        controlDTO.setIdPersona(persona.getIdPersona());
        listaControl = administrarHistoriasClinicasBean.buscarControl(controlDTO);
        if (listaControl == null || listaControl.isEmpty()) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_INFO, INFORMACION, MensajeUtils.getMensaje("noExistenControles")));
        }
    }

    /**
     * Metodo utilizado para iniciar los valores de los tabs de controles
     *
     * @return regla de navegacion
     */
    public String crearControl() {
        if (controlCrear != null) {
            msg = new FacesMessage(FacesMessage.SEVERITY_WARN, ADVERTENCIA, MensajeUtils.getMensaje("concurrencyControl"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
            return "";
        }
        controlCrear = new TControl();
        controlCrear.settPersona(persona);
        controlCrear.settProfesional(profesional);
        controlCrear.setFeControl(Calendar.getInstance().getTime());

        agudezaVisual = new TAgudezaVisual();
        agudezaVisual.setTControl(controlCrear);

        lensometria = new TLensometria();
        lensometria.setTControl(controlCrear);

        prescripcion = new TPrescripcion();
        prescripcion.setTControl(controlCrear);

        prescripcionLentes = new TPrescripcionLentesContacto();
        prescripcionLentes.setTControl(controlCrear);

        prescripcionMedica = new TPrescripcionMedica();
        prescripcionMedica.setTControl(controlCrear);

        oftalmoscopia = new TOftalmoscopia();
        oftalmoscopia.setTControl(controlCrear);

        queratometria = new TQueratometria();
        queratometria.setTControl(controlCrear);

        refraccion = new TRefraccion();
        refraccion.setTControl(controlCrear);

        subjetivo = new TSubjetivo();
        subjetivo.setTControl(controlCrear);

        afinacion = new TAfinacion();
        afinacion.setTControl(controlCrear);

        adicion = new TAdicion();
        adicion.setTControl(controlCrear);

        examenMotor = new TExamenMotor();
        examenMotor.setTControl(controlCrear);

        diagnosticoManejo = new TDiagnosticoManejo();
        diagnosticoManejo.setTControl(controlCrear);
        listaDiagnosticos = new ArrayList<TDiagnostico>();

        biomicrospia = new TMicroscopia();
        biomicrospia.setTControl(controlCrear);
        biomicrospia.setIsNormal(false);
        biomicrospia.setHoraMostrar(Calendar.getInstance().getTime());

        listaPatologias = administrarHistoriasClinicasBean.consultarPatologias();
        listaOptotiposVP = administrarHistoriasClinicasBean.consultarTipoOptotipos(SubTipoOptoTipoEnum.VISION_PROXIMA);
        listaOptotiposVL = administrarHistoriasClinicasBean.consultarTipoOptotipos(SubTipoOptoTipoEnum.VISION_LEJANA);
        listaTipoLentes = administrarHistoriasClinicasBean.consultarTipoLentes();
        listaTipoMateriales = administrarHistoriasClinicasBean.consultarTipoMateriales();

        listaMedicamentos = administrarHistoriasClinicasBean.consultarMedicamentos();
        listaMedicamentosSelected = new ArrayList<TMedicamento>();
        medicamentoSearch = new TCatalogoMedicamento();
        listaGenericos = new ArrayList<String>();
        listaNombresComerciales = new ArrayList<String>();
        limpiarFiltroBusquedaMedicamento();
        loadDefault();
        selectedTab = 0;
        return "crear_control";
    }

    private void loadDefault() {

        agudezaVisual.setDistanciaVl(Constantes.DISTANCIA_VL_AGUDEZA_DEFAULT);
        agudezaVisual.setDistanciaVp(Constantes.DISTANCIA_VP_AGUDEZA_DEFAULT);

        for (TTipOptotipo optoAux : listaOptotiposVL) {
            if (optoAux.getDesTipOptotipo().equals(Constantes.OPTOTIPO_VL_AGUDEZA_DEFAULT)) {
                agudezaVisual.setTTipOptotipo(optoAux);
                break;
            }
        }

        for (TTipOptotipo optoAux : listaOptotiposVP) {
            if (optoAux.getDesTipOptotipo().equals(Constantes.OPTOTIPO_VP_AGUDEZA_DEFAULT)) {
                agudezaVisual.setTTipoOptotipoVp(optoAux);
                break;
            }
        }

        oftalmoscopia.setDesBruckner(BrucknerEnum.SIMETRICO);
        oftalmoscopia.setMedRefracOd(MedioRefractanteEnum.TRANSPARENTE);
        oftalmoscopia.setMedRefracOi(MedioRefractanteEnum.TRANSPARENTE);
        oftalmoscopia.setTecnica(TecnicaEnum.DIRECTA);

        queratometria.setDesEqui(EquipoEnum.BAUSHLOMB);
        queratometria.setMiraOd(MiraEnum.COMPLETAS);
        queratometria.setMiraOi(MiraEnum.COMPLETAS);
        queratometria.setAstgOd(Constantes.ASTIGMATISMO_CORNEAL_QUERATOMETRIA_DEFAULT);
        queratometria.setAstgOi(Constantes.ASTIGMATISMO_CORNEAL_QUERATOMETRIA_DEFAULT);

        refraccion.setDesTipoPri(TipoRefraccionEnum.RETINOSCOPIA_ESTATICA);
        refraccion.setDesTipoSec(TipoRefraccionEnum.RETINOSCOPIA_DINAMICA);

        for (TTipoMaterial tipoAux : listaTipoMateriales) {
            if (tipoAux.getDesNombre().equals(Constantes.MATERIAL_LENTE_PRES_OPTICA_DEFAULT)) {
                prescripcion.settTipoMaterial(tipoAux);
                break;
            }
        }

        TDiagnostico diagnosticoTemp = new TDiagnostico();
        diagnosticoTemp.setTPatologia(new TPatologia());
        diagnosticoTemp.setTDiagnosticoManejo(diagnosticoManejo);

        for (TPatologia patologiaTemp : listaPatologias) {
            if (patologiaTemp.getDesNombre().equals(Constantes.PATOLOGIA_DIAGNOSTICO_DEFAULT)) {
                diagnosticoTemp.setTPatologia(patologiaTemp);
            }
        }
        listaDiagnosticos.add(diagnosticoTemp);

    }

    public String modificarControl(TControl controlSelected) {
        if (controlCrear != null) {
            msg = new FacesMessage(FacesMessage.SEVERITY_WARN, ADVERTENCIA, MensajeUtils.getMensaje("concurrencyControl"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
            return "";
        }

        if (!administrarHistoriasClinicasBean.validarModificacion(controlSelected)) {
            msg = new FacesMessage(FacesMessage.SEVERITY_WARN, ADVERTENCIA, MensajeUtils.getMensaje("validacionTiempoModificacion"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
            return "";
        }
        controlCrear = controlSelected;

        agudezaVisual = administrarHistoriasClinicasBean.consultarAgudezaVisual(controlCrear);
        lensometria = administrarHistoriasClinicasBean.consultarLensometria(controlCrear);
        prescripcion = administrarHistoriasClinicasBean.consultarPrescripcion(controlCrear);
        prescripcionLentes = administrarHistoriasClinicasBean.consultarPrescripcionLentes(controlCrear);
        prescripcionMedica = administrarHistoriasClinicasBean.consultarPrescripcionMedica(controlCrear);
        oftalmoscopia = administrarHistoriasClinicasBean.consultarOftalmoscopia(controlCrear);
        queratometria = administrarHistoriasClinicasBean.consultarQueratometria(controlCrear);
        refraccion = administrarHistoriasClinicasBean.consultarRefraccion(controlCrear);
        subjetivo = administrarHistoriasClinicasBean.consultarSubjetivo(controlCrear);
        afinacion = administrarHistoriasClinicasBean.consultarAfinacion(controlCrear);
        adicion = administrarHistoriasClinicasBean.consultarAdicion(controlCrear);

        diagnosticoManejo = administrarHistoriasClinicasBean.consultarDiagnosticoManejo(controlCrear);
        listaDiagnosticos = new ArrayList<TDiagnostico>();
        if (diagnosticoManejo != null && diagnosticoManejo.getIdDiagnosticoMedico() != null) {
            listaDiagnosticos = administrarHistoriasClinicasBean.consultarDiagnosticos(diagnosticoManejo);
        }

        examenMotor = administrarHistoriasClinicasBean.consultarExamenMotor(controlCrear);
        biomicrospia = administrarHistoriasClinicasBean.consultarBiomicroscopia(controlCrear);
        if (biomicrospia.getIsNormal() == null) {
            biomicrospia.setIsNormal(false);
        }
        establecerHora();

        listaPatologias = administrarHistoriasClinicasBean.consultarPatologias();
        listaOptotiposVP = administrarHistoriasClinicasBean.consultarTipoOptotipos(SubTipoOptoTipoEnum.VISION_PROXIMA);
        listaOptotiposVL = administrarHistoriasClinicasBean.consultarTipoOptotipos(SubTipoOptoTipoEnum.VISION_LEJANA);
        listaTipoLentes = administrarHistoriasClinicasBean.consultarTipoLentes();
        listaTipoMateriales = administrarHistoriasClinicasBean.consultarTipoMateriales();
        listaMedicamentos = administrarHistoriasClinicasBean.consultarMedicamentos();

        listaMedicamentosSelected = administrarHistoriasClinicasBean.consultarMedicamentosPrescripcion(prescripcionMedica);
        medicamentoSearch = new TCatalogoMedicamento();
        listaGenericos = new ArrayList<String>();
        listaNombresComerciales = new ArrayList<String>();
        limpiarFiltroBusquedaMedicamento();
        selectedTab = 0;
        return "crear_control";
    }

    public void validateFecha(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        Calendar sysDate = Calendar.getInstance();
        Calendar toValidate = Calendar.getInstance();
        toValidate.setTime((Date) value);
        if (toValidate.getTimeInMillis() < sysDate.getTimeInMillis()) {
            throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("fechaMayorSistema")));
        }
    }

    private void establecerHora() {
        if (biomicrospia == null || biomicrospia.getDesHora() == null
                || biomicrospia.getDesHora().trim().length() == 0) {
            return;
        }

        Calendar c = Calendar.getInstance();
        String hm[] = biomicrospia.getDesHora().split(":");
        c.set(1970, 0, 0, Integer.parseInt(hm[0]), Integer.parseInt(hm[1]));
        biomicrospia.setHoraMostrar(c.getTime());
    }

    public List<String> autoCompleteEsfera(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_ESFERA.length; i++) {
            if (ListasUtils.LISTA_ESFERA[i].contains(key)) {
                results.add(ListasUtils.LISTA_ESFERA[i]);
            }
        }
        return results;
    }

    public List<String> autoCompleteCilindro(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_CILINDRO.length; i++) {
            if (ListasUtils.LISTA_CILINDRO[i].contains(key)) {
                results.add(ListasUtils.LISTA_CILINDRO[i]);
            }
        }
        return results;
    }

    public List<String> autoCompleteEje(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_EJE.length; i++) {
            if (ListasUtils.LISTA_EJE[i].contains(key)) {
                results.add(ListasUtils.LISTA_EJE[i]);
            }
        }
        return results;
    }

    public List<String> autoCompleteAdd(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_ADD.length; i++) {
            if (ListasUtils.LISTA_ADD[i].contains(key)) {
                results.add(ListasUtils.LISTA_ADD[i]);
            }
        }
        return results;
    }

    public List<String> autoCompleteCantidadQueratometria(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_A1B1_QUERATOMETRIA.length; i++) {
            if (ListasUtils.LISTA_A1B1_QUERATOMETRIA[i].contains(key)) {
                results.add(ListasUtils.LISTA_A1B1_QUERATOMETRIA[i]);
            }
        }
        return results;
    }

    public void validateCantidadQueratometria(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        for (int i = 0; i < ListasUtils.LISTA_A1B1_QUERATOMETRIA.length; i++) {
            if (ListasUtils.LISTA_A1B1_QUERATOMETRIA[i].equals(value.toString())) {
                return;
            }
        }
        throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("validateCantidadQueratometria")));
    }

    public List<String> autoCompleteC1Queratometria(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_C1_QUERATOMETRIA.length; i++) {
            if (ListasUtils.LISTA_C1_QUERATOMETRIA[i].contains(key)) {
                results.add(ListasUtils.LISTA_C1_QUERATOMETRIA[i]);
            }
        }
        return results;
    }

    public void validateC1Queratometria(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        for (int i = 0; i < ListasUtils.LISTA_C1_QUERATOMETRIA.length; i++) {
            if (ListasUtils.LISTA_C1_QUERATOMETRIA[i].equals(value.toString())) {
                return;
            }
        }
        throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("validateC1Queratometria")));
    }

    public List<String> autoCompletePPC(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_PPC.length; i++) {
            if (ListasUtils.LISTA_PPC[i].contains(key)) {
                results.add(ListasUtils.LISTA_PPC[i]);
            }
        }
        return results;
    }

    public void validatePPC(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        for (int i = 0; i < ListasUtils.LISTA_PPC.length; i++) {
            if (ListasUtils.LISTA_PPC[i].equals(value.toString())) {
                return;
            }
        }
        throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("validatePPC")));
    }

    public List<String> autoCompleteVLVP(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_VLVP_EXAMEN_MOTOR.length; i++) {
            if (ListasUtils.LISTA_VLVP_EXAMEN_MOTOR[i].contains(key)) {
                results.add(ListasUtils.LISTA_VLVP_EXAMEN_MOTOR[i]);
            }
        }
        return results;
    }

    public void validateVLVP(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        for (int i = 0; i < ListasUtils.LISTA_VLVP_EXAMEN_MOTOR.length; i++) {
            if (ListasUtils.LISTA_VLVP_EXAMEN_MOTOR[i].equals(value.toString())) {
                return;
            }
        }
        throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("validatorVLVP")));
    }

    public List<String> autoCompleteDistancias(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_DISTANCIAS.length; i++) {
            if (ListasUtils.LISTA_DISTANCIAS[i].contains(key)) {
                results.add(ListasUtils.LISTA_DISTANCIAS[i]);
            }
        }
        return results;
    }

    public void validateDistancias(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        for (int i = 0; i < ListasUtils.LISTA_DISTANCIAS.length; i++) {
            if (ListasUtils.LISTA_DISTANCIAS[i].equals(value.toString())) {
                return;
            }
        }
        throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("validatorDistancias")));
    }

    public List<String> autoCompletePatologia(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < listaPatologias.size(); i++) {
            if (listaPatologias.get(i).getDesNombre().toLowerCase().contains(key.toLowerCase())) {
                results.add(listaPatologias.get(i).getDesNombre());
            }
        }
        return results;
    }

    public void validatePatologia(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        for (int i = 0; i < listaPatologias.size(); i++) {
            if (listaPatologias.get(i).getDesNombre().equals(value.toString())) {
                return;
            }
        }
        throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("validatorPatologias")));
    }

    public List<String> autoCompleteTanometria(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_TANOMETRIA.length; i++) {
            if (ListasUtils.LISTA_TANOMETRIA[i].contains(key)) {
                results.add(ListasUtils.LISTA_TANOMETRIA[i]);
            }
        }
        return results;
    }

    public void validateTanometria(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        for (int i = 0; i < ListasUtils.LISTA_TANOMETRIA.length; i++) {
            if (ListasUtils.LISTA_TANOMETRIA[i].equals(value.toString())) {
                return;
            }
        }
        throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("validateTanometria")));
    }

    public List<String> autoCompleteCantidadPresMedica(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_CANTIDAD_PRES_MEDICA.length; i++) {
            if (ListasUtils.LISTA_CANTIDAD_PRES_MEDICA[i].contains(key)) {
                results.add(ListasUtils.LISTA_CANTIDAD_PRES_MEDICA[i]);
            }
        }
        return results;
    }

    public void validateCantidadPresMedica(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        for (int i = 0; i < ListasUtils.LISTA_CANTIDAD_PRES_MEDICA.length; i++) {
            if (ListasUtils.LISTA_CANTIDAD_PRES_MEDICA[i].equals(value.toString())) {
                return;
            }
        }
        throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("validateCantidadPresMedica")));
    }

    public List<String> autoCompleteCadaPresMedica(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_CADA_PRES_MEDICA.length; i++) {
            if (ListasUtils.LISTA_CADA_PRES_MEDICA[i].contains(key)) {
                results.add(ListasUtils.LISTA_CADA_PRES_MEDICA[i]);
            }
        }
        return results;
    }

    public void validateCadaPresMedica(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        for (int i = 0; i < ListasUtils.LISTA_CADA_PRES_MEDICA.length; i++) {
            if (ListasUtils.LISTA_CADA_PRES_MEDICA[i].equals(value.toString())) {
                return;
            }
        }
        throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("validateCadaPresMedica")));
    }

    public List<String> autoCompleteTiempoPresMedica(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_PERIODO_PRES_MEDICA.length; i++) {
            if (ListasUtils.LISTA_PERIODO_PRES_MEDICA[i].contains(key)) {
                results.add(ListasUtils.LISTA_PERIODO_PRES_MEDICA[i]);
            }
        }
        return results;
    }

    public void validateTiempoPresMedica(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        for (int i = 0; i < ListasUtils.LISTA_PERIODO_PRES_MEDICA.length; i++) {
            if (ListasUtils.LISTA_PERIODO_PRES_MEDICA[i].equals(value.toString())) {
                return;
            }
        }
        throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("validateTiempoPresMedica")));
    }

    public List<String> autoCompleteDistMetrosAgudezaVisual(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_DIST_METROS_AGUDEZA_VISUAL.length; i++) {
            if (ListasUtils.LISTA_DIST_METROS_AGUDEZA_VISUAL[i].contains(key)) {
                results.add(ListasUtils.LISTA_DIST_METROS_AGUDEZA_VISUAL[i]);
            }
        }
        return results;
    }

    public void validateDistMetrosAgudezaVisual(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        for (int i = 0; i < ListasUtils.LISTA_DIST_METROS_AGUDEZA_VISUAL.length; i++) {
            if (ListasUtils.LISTA_DIST_METROS_AGUDEZA_VISUAL[i].equals(value.toString())) {
                return;
            }
        }
        throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("validateDistMetrosAgudezaVisual")));
    }

    public List<String> autoCompleteDistMetrosExamenMotor(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_DIST_METROS_EXAMEN_MOTOR.length; i++) {
            if (ListasUtils.LISTA_DIST_METROS_EXAMEN_MOTOR[i].contains(key)) {
                results.add(ListasUtils.LISTA_DIST_METROS_EXAMEN_MOTOR[i]);
            }
        }
        return results;
    }

    public void validateDistMetrosExamenMotor(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        for (int i = 0; i < ListasUtils.LISTA_DIST_METROS_EXAMEN_MOTOR.length; i++) {
            if (ListasUtils.LISTA_DIST_METROS_EXAMEN_MOTOR[i].equals(value.toString())) {
                return;
            }
        }
        throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("validateDistMetrosAgudezaVisual")));
    }

    public List<String> autoCompleteDistCentimetrosMetrosAgudezaVisual(String key) {
        List<String> results = new ArrayList<String>();

        for (int i = 0; i < ListasUtils.LISTA_DIST_CENTIMETROS_AGUDEZA_VISUAL.length; i++) {
            if (ListasUtils.LISTA_DIST_CENTIMETROS_AGUDEZA_VISUAL[i].contains(key)) {
                results.add(ListasUtils.LISTA_DIST_CENTIMETROS_AGUDEZA_VISUAL[i]);
            }
        }
        return results;
    }

    public void validateDistCentimetrosMetrosAgudezaVisual(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        for (int i = 0; i < ListasUtils.LISTA_DIST_CENTIMETROS_AGUDEZA_VISUAL.length; i++) {
            if (ListasUtils.LISTA_DIST_CENTIMETROS_AGUDEZA_VISUAL[i].equals(value.toString())) {
                return;
            }
        }
        throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("validateDistCentimetrosMetrosAgudezaVisual")));
    }

    public void calcularAstigmatismo(boolean isOjoDerecho) {
        if (isOjoDerecho && queratometria.getOdA() != null
                && queratometria.getOdA().length() > 0
                && queratometria.getOdB() != null
                && queratometria.getOdB().length() > 0
                && queratometria.getOdC() != null
                && queratometria.getOdC().length() > 0) {
            Double result = Double.parseDouble(queratometria.getOdA())
                    - Double.parseDouble(queratometria.getOdB());
            queratometria.setAstgOd("" + result + " X "
                    + queratometria.getOdC());
        } else if (!isOjoDerecho && queratometria.getOiA() != null
                && queratometria.getOiA().length() > 0
                && queratometria.getOiB() != null
                && queratometria.getOiB().length() > 0
                && queratometria.getOiC() != null
                && queratometria.getOiC().length() > 0) {
            Double result = Double.parseDouble(queratometria.getOiA())
                    - Double.parseDouble(queratometria.getOiB());
            queratometria.setAstgOi("" + result + " X "
                    + queratometria.getOiC());
        }
    }

    public void adicionarDiagnostico() {

        if (!validarDiagnosticos()) {
            return;
        }
        TDiagnostico diagnostico = new TDiagnostico();
        diagnostico.setTPatologia(new TPatologia());
        diagnostico.setTDiagnosticoManejo(diagnosticoManejo);
        listaDiagnosticos.add(diagnostico);
    }

    private boolean validarDiagnosticos() {
        if (listaDiagnosticos.size() > 0) {
            for (TDiagnostico diagnosticoAux : listaDiagnosticos) {
                if (diagnosticoAux.getTPatologia().getIdPatologia() == null) {
                    msg = new FacesMessage(FacesMessage.SEVERITY_WARN, INFORMACION, MensajeUtils.getMensaje("imposibleAdicionarDiagnostico"));
                    FacesContext.getCurrentInstance().addMessage(null, msg);
                    return false;
                }
            }
        }
        return true;
    }

    public void sumprimirDiagnostico(TDiagnostico diagnosticoSelected) {
        listaDiagnosticos.remove(diagnosticoSelected);

    }

    public void onEdit(RowEditEvent event) {
        msg = new FacesMessage(INFORMACION, MensajeUtils.getMensaje("diagnosticoEditado"));
        FacesContext.getCurrentInstance().addMessage(null, msg);
    }

    public void crearMotivoConsulta() {
        try {
            TProfesional user = new TProfesional();
            user.setUserName("javier.rey");
            //administrarHistoriasClinicasBean.crearMotivoConsulta(controlCrear, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean.crearMotivoConsulta(controlCrear, user);
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO, INFORMACION, MensajeUtils.getMensaje("motivoConsultaExitosa"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        } catch (Exception ole) {
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR, ERROR, MensajeUtils.getMensaje("concurrencyError"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }
    }

    public void crearAgudezaVisual() {
        try {
            TProfesional user = new TProfesional();
            user.setUserName("javier.rey");
            //administrarHistoriasClinicasBean.crearAgudezaVisual(agudezaVisual, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean.crearAgudezaVisual(agudezaVisual, user);
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO, INFORMACION, MensajeUtils.getMensaje("agudezaExitosa"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        } catch (Exception ole) {
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR, ERROR, MensajeUtils.getMensaje("concurrencyError"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }
    }

    public void crearLensometria() {
        try {
            TProfesional user = new TProfesional();
            user.setUserName("javier.rey");
            //administrarHistoriasClinicasBean.crearLensometria(lensometria, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean.crearLensometria(lensometria, user);
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
                    INFORMACION, MensajeUtils.getMensaje("lensometriaExitosa"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        } catch (Exception ole) {
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    ERROR, MensajeUtils.getMensaje("concurrencyError"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }
    }

    public void crearPrescripcion() {
        try {
            TProfesional user = new TProfesional();
            user.setUserName("javier.rey");
            //administrarHistoriasClinicasBean.crearPrescripcion(prescripcion, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean.crearPrescripcion(prescripcion, user);
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
                    INFORMACION, MensajeUtils.getMensaje("prescripcionExitosa"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        } catch (Exception ole) {
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    ERROR, MensajeUtils.getMensaje("concurrencyError"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }
    }

    public void crearPrescripcionLentes() {
        try {
            TProfesional user = new TProfesional();
            user.setUserName("javier.rey");
            //administrarHistoriasClinicasBean.crearPrescripcionLentes(prescripcionLentes, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean.crearPrescripcionLentes(prescripcionLentes, user);
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
                    INFORMACION, MensajeUtils.getMensaje("prescripcionLentesExitosa"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        } catch (Exception ole) {
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    ERROR, MensajeUtils.getMensaje("concurrencyError"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }
    }

    public void crearPrescripcionMedica() {
        try {
            TProfesional user = new TProfesional();
            user.setUserName("javier.rey");
            //administrarHistoriasClinicasBean
            //.crearPrescripcionMedica(prescripcionMedica, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean
                    .crearPrescripcionMedica(prescripcionMedica, user);
            //administrarHistoriasClinicasBean
            //      .guardarMedicamentos(listaMedicamentosSelected, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean
                    .guardarMedicamentos(listaMedicamentosSelected, user);
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
                    INFORMACION,
                    MensajeUtils.getMensaje("prescripcionMedicaExitosa"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        } catch (Exception ole) {
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    ERROR, MensajeUtils.getMensaje("concurrencyError"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }
    }

    public void crearExamenMotor() {
        try {
            TProfesional user = new TProfesional();
            user.setUserName("javier.rey");
            //administrarHistoriasClinicasBean.crearExamenMotor(examenMotor, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean.crearExamenMotor(examenMotor, user);
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
                    INFORMACION, MensajeUtils.getMensaje("examenMotorExitoso"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        } catch (Exception ole) {
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    ERROR, MensajeUtils.getMensaje("concurrencyError"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }
    }

    public void crearOftalmoscopia() {
        try {
            TProfesional user = new TProfesional();
            user.setUserName("javier.rey");
            //administrarHistoriasClinicasBean.crearOftalmoscopia(oftalmoscopia, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean.crearOftalmoscopia(oftalmoscopia, user);
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
                    INFORMACION,
                    MensajeUtils.getMensaje("oftalmoscopiaExitosa"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        } catch (Exception ole) {
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    ERROR, MensajeUtils.getMensaje("concurrencyError"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }
    }

    public void crearBiomicroscopia() {
        try {
            if (biomicrospia.getHoraMostrar() != null) {
                biomicrospia.setDesHora(formatHora.format(biomicrospia
                        .getHoraMostrar()));
            }
            TProfesional user = new TProfesional();
            user.setUserName("javier.rey");

            //administrarHistoriasClinicasBean.crearBiomicroscopia(biomicrospia, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean.crearBiomicroscopia(biomicrospia, user);
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
                    INFORMACION,
                    MensajeUtils.getMensaje("biomicroscopiaExitosa"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        } catch (Exception ole) {
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    ERROR, MensajeUtils.getMensaje("concurrencyError"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }
    }

    public String habilitarPaintingBoard(boolean isOjoDerecho) {
        editingOjoDerecho = isOjoDerecho;
        if (isOjoDerecho) {
            tituloCanvas = "Editar ojo derecho";
        } else {
            tituloCanvas = "Editar Ojo izquierdo";
        }

        return "painting_board.xhtml?faces-redirect=true";
    }

    public void crearQueratometria() {
        try {
            TProfesional user = new TProfesional();
            user.setUserName("javier.rey");

            //administrarHistoriasClinicasBean.crearQueratometria(queratometria, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean.crearQueratometria(queratometria, user);
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
                    INFORMACION,
                    MensajeUtils.getMensaje("queratometriaExitosa"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        } catch (Exception ole) {
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    ERROR, MensajeUtils.getMensaje("concurrencyError"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }
    }

    public void crearRefraccion() {
        try {
            TProfesional user = new TProfesional();
            user.setUserName("javier.rey");
            //administrarHistoriasClinicasBean.crearRefraccion(refraccion, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean.crearRefraccion(refraccion, user);
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
                    INFORMACION, MensajeUtils.getMensaje("refraccionExitosa"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        } catch (Exception ole) {
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    ERROR, MensajeUtils.getMensaje("concurrencyError"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }
    }

    public void crearSubjetivo() {
        try {
            TProfesional user = new TProfesional();
            user.setUserName("javier.rey");
            //administrarHistoriasClinicasBean.crearSubjetivo(subjetivo, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean.crearSubjetivo(subjetivo, user);
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
                    INFORMACION, MensajeUtils.getMensaje("subjetivoExitoso"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        } catch (Exception ole) {
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    ERROR, MensajeUtils.getMensaje("concurrencyError"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }
    }

    public void crearAfinacion() {
        try {
            TProfesional user = new TProfesional();
            user.setUserName("javier.rey");
            //administrarHistoriasClinicasBean.crearAfinacion(afinacion, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean.crearAfinacion(afinacion, user);
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
                    INFORMACION, MensajeUtils.getMensaje("afinacionExitosa"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        } catch (Exception ole) {
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    ERROR, MensajeUtils.getMensaje("concurrencyError"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }
    }

    public void crearDiagnosticoManejo() {
        try {
            if (!validarDiagnosticos()) {
                return;
            }
            TProfesional user = new TProfesional();
            user.setUserName("javier.rey");

            //administrarHistoriasClinicasBean
            //      .crearDiagnosticoManejo(diagnosticoManejo, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean
                    .crearDiagnosticoManejo(diagnosticoManejo, user);
            //administrarHistoriasClinicasBean
            //      .crearDiagnosticos(listaDiagnosticos, administrarLoginAction.getUser());
            administrarHistoriasClinicasBean
                    .crearDiagnosticos(listaDiagnosticos, user);
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO,
                    INFORMACION, MensajeUtils.getMensaje("diagnosticoExitoso"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        } catch (Exception ole) {
            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    ERROR, MensajeUtils.getMensaje("concurrencyError"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }
    }

    public void mapPatalogiaDiagnostico() {
        if (listaDiagnosticos != null && !listaDiagnosticos.isEmpty()) {
            for (TDiagnostico diagnosticoTemp : listaDiagnosticos) {
                for (TPatologia patologiaTemp : listaPatologias) {
                    if (diagnosticoTemp.getTPatologia().getDesNombre().equals(patologiaTemp.getDesNombre())) {
                        diagnosticoTemp.setTPatologia(patologiaTemp);
                        break;
                    }
                }
            }
        }
    }

    public void limpiarFiltroBusquedaMedicamento() {
        medicamentoSearch = new TCatalogoMedicamento();
        listaMedicamentosResult = new ArrayList<TCatalogoMedicamento>();
    }

    public void cambiarListaGenerico() {
        listaGenericos = new ArrayList<String>();
        listaPresentaciones = new ArrayList<PresentacionEnum>();
        listaNombresComerciales = new ArrayList<String>();

        for (TCatalogoMedicamento med : listaMedicamentos) {
            if (medicamentoSearch.getTipoMed().equals(med.getTipoMed()) && !listaGenericos.contains(med.getNomGen())) {
                listaGenericos.add(med.getNomGen());
            }
        }
    }

    public void cambiarListaPresentacion() {
        listaPresentaciones = new ArrayList<PresentacionEnum>();
        listaNombresComerciales = new ArrayList<String>();

        for (TCatalogoMedicamento med : listaMedicamentos) {
            if (medicamentoSearch.getNomGen().equals(med.getNomGen()) && !listaPresentaciones.contains(med.getDesPres())) {
                listaPresentaciones.add(med.getDesPres());
            }
        }

    }

    public void cambiarListaNombresComerciales() {
        listaNombresComerciales = new ArrayList<String>();

        for (TCatalogoMedicamento med : listaMedicamentos) {
            if (medicamentoSearch.getDesPres().equals(med.getDesPres())) {
                listaNombresComerciales.add(med.getNomCom());
            }
        }
    }

    public void buscarMedicamentos() {
        listaMedicamentosResult = administrarHistoriasClinicasBean.buscarMedicamentos(medicamentoSearch);
        if (listaMedicamentosResult == null || listaMedicamentosResult.isEmpty()) {
            msg = new FacesMessage(FacesMessage.SEVERITY_INFO, INFORMACION, MensajeUtils.getMensaje("noExistenMedicamentos"));
            FacesContext.getCurrentInstance().addMessage(null, msg);
        }

    }

    public void adicionarMedicamento(TCatalogoMedicamento catalogoSelected) {
        TMedicamento med = new TMedicamento();
        med.setCatalogo(catalogoSelected);
        med.setPrescripcion(prescripcionMedica);
        listaMedicamentosSelected.add(med);
    }

    public void sumprimirMedicamento(TMedicamento medicamentoSelected) {
        listaMedicamentosSelected.remove(medicamentoSelected);
    }

    public void limpiarPersona() {
        this.persona = null;
    }

    public String cancelar() {
        this.persona = null;
        return "gestionar_personas?faces-redirect=true";
    }

    public String cancelarControl() {
        controlCrear = null;
        buscarControl();
        return "gestionar_control?faces-redirect=true";
    }

    public void borrarHirschberg() {
        examenMotor.setHirObs(null);
    }

    public void validateEsferaCilindroEje(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        for (int i = 0; i < ListasUtils.LISTA_ESFERA.length; i++) {
            if (ListasUtils.LISTA_ESFERA[i].equals(value.toString())) {
                return;
            }
        }

        for (int i = 0; i < ListasUtils.LISTA_CILINDRO.length; i++) {
            if (ListasUtils.LISTA_CILINDRO[i].equals(value.toString())) {
                return;
            }
        }

        for (int i = 0; i < ListasUtils.LISTA_EJE.length; i++) {
            if (ListasUtils.LISTA_EJE[i].equals(value.toString())) {
                return;
            }
        }

        throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("validatorEjeCilEsf")));

    }

    public void validateAdd(FacesContext ctx, UIComponent component,
            Object value) throws ValidatorException {

        for (int i = 0; i < ListasUtils.LISTA_ADD.length; i++) {
            if (ListasUtils.LISTA_ADD[i].equals(value.toString())) {
                return;
            }
        }
        throw new ValidatorException(new FacesMessage(FacesMessage.SEVERITY_ERROR, INFORMACION, MensajeUtils.getMensaje("validatorAdd")));

    }

    public String setActiveTab() {
        selectedTab = 4;
        return "/crear_control.xhtml?faces-redirect=true";
    }

    public TPersona getPersona() {
        return persona;
    }

    public void setPersona(TPersona persona) {
        this.persona = persona;
    }

    public Date getFechaInicial() {
        return fechaInicial;
    }

    public void setFechaInicial(Date fechaInicial) {
        this.fechaInicial = fechaInicial;
    }

    public Date getFechaFinal() {
        return fechaFinal;
    }

    public void setFechaFinal(Date fechaFinal) {
        this.fechaFinal = fechaFinal;
    }

    public List<TControl> getListaControl() {
        return listaControl;
    }

    public void setListaControl(List<TControl> listaControl) {
        this.listaControl = listaControl;
    }

    public TControl getControlCrear() {
        return controlCrear;
    }

    public void setControlCrear(TControl controlCrear) {
        this.controlCrear = controlCrear;
    }

    public TAgudezaVisual getAgudezaVisual() {
        return agudezaVisual;
    }

    public void setAgudezaVisual(TAgudezaVisual agudezaVisual) {
        this.agudezaVisual = agudezaVisual;
    }

    public TLensometria getLensometria() {
        return lensometria;
    }

    public void setLensometria(TLensometria lensometria) {
        this.lensometria = lensometria;
    }

    public List<TTipLente> getListaTipoLentes() {
        return listaTipoLentes;
    }

    public void setListaTipoLentes(List<TTipLente> listaTipoLentes) {
        this.listaTipoLentes = listaTipoLentes;
    }

    public TPrescripcion getPrescripcion() {
        return prescripcion;
    }

    public void setPrescripcion(TPrescripcion prescripcion) {
        this.prescripcion = prescripcion;
    }

    public TOftalmoscopia getOftalmoscopia() {
        return oftalmoscopia;
    }

    public void setOftalmoscopia(TOftalmoscopia oftalmoscopia) {
        this.oftalmoscopia = oftalmoscopia;
    }

    public TQueratometria getQueratometria() {
        return queratometria;
    }

    public void setQueratometria(TQueratometria queratometria) {
        this.queratometria = queratometria;
    }

    public TRefraccion getRefraccion() {
        return refraccion;
    }

    public void setRefraccion(TRefraccion refraccion) {
        this.refraccion = refraccion;
    }

    public TSubjetivo getSubjetivo() {
        return subjetivo;
    }

    public void setSubjetivo(TSubjetivo subjetivo) {
        this.subjetivo = subjetivo;
    }

    public TAdicion getAdicion() {
        return adicion;
    }

    public void setAdicion(TAdicion adicion) {
        this.adicion = adicion;
    }

    public TDiagnosticoManejo getDiagnosticoManejo() {
        return diagnosticoManejo;
    }

    public void setDiagnosticoManejo(TDiagnosticoManejo diagnosticoManejo) {
        this.diagnosticoManejo = diagnosticoManejo;
    }

    public TExamenMotor getExamenMotor() {
        return examenMotor;
    }

    public void setExamenMotor(TExamenMotor examenMotor) {
        this.examenMotor = examenMotor;
    }

    public TMicroscopia getBiomicrospia() {
        return biomicrospia;
    }

    public void setBiomicrospia(TMicroscopia biomicrospia) {
        this.biomicrospia = biomicrospia;
    }

    public List<TTipoMaterial> getListaTipoMateriales() {
        return listaTipoMateriales;
    }

    public void setListaTipoMateriales(List<TTipoMaterial> listaTipoMateriales) {
        this.listaTipoMateriales = listaTipoMateriales;
    }

    public List<TDiagnostico> getListaDiagnosticos() {
        return listaDiagnosticos;
    }

    public void setListaDiagnosticos(List<TDiagnostico> listaDiagnosticos) {
        this.listaDiagnosticos = listaDiagnosticos;
    }

    public List<TPatologia> getListaPatologias() {
        return listaPatologias;
    }

    public void setListaPatologias(List<TPatologia> listaPatologias) {
        this.listaPatologias = listaPatologias;
    }

    public List<DistanciaEnum> getListaDistancias() {
        return listaDistancias;
    }

    public void setListaDistancias(List<DistanciaEnum> listaDistancias) {
        this.listaDistancias = listaDistancias;
    }

    public List<EsferaCilindroEnum> getListaEsferaCilindro() {
        return listaEsferaCilindro;
    }

    public void setListaEsferaCilindro(List<EsferaCilindroEnum> listaEsferaCilindro) {
        this.listaEsferaCilindro = listaEsferaCilindro;
    }

    public List<EjeEnum> getListaEje() {
        return listaEje;
    }

    public void setListaEje(List<EjeEnum> listaEje) {
        this.listaEje = listaEje;
    }

    public TAfinacion getAfinacion() {
        return afinacion;
    }

    public void setAfinacion(TAfinacion afinacion) {
        this.afinacion = afinacion;
    }

    public List<UsoEnum> getListaUsos() {
        return listaUsos;
    }

    public void setListaUsos(List<UsoEnum> listaUsos) {
        this.listaUsos = listaUsos;
    }

    public List<RemisionEnum> getListaRemision() {
        return listaRemision;
    }

    public void setListaRemision(List<RemisionEnum> listaRemision) {
        this.listaRemision = listaRemision;
    }

    public List<ExamenApoyoEnum> getListaExamenApoyo() {
        return listaExamenApoyo;
    }

    public void setListaExamenApoyo(List<ExamenApoyoEnum> listaExamenApoyo) {
        this.listaExamenApoyo = listaExamenApoyo;
    }

    public List<OjoEnum> getListaMedioRefraccion() {
        return listaMedioRefraccion;
    }

    public void setListaMedioRefraccion(List<OjoEnum> listaMedioRefraccion) {
        this.listaMedioRefraccion = listaMedioRefraccion;
    }

    public List<TecnicaEnum> getListaTecnicas() {
        return listaTecnicas;
    }

    public void setListaTecnicas(List<TecnicaEnum> listaTecnicas) {
        this.listaTecnicas = listaTecnicas;
    }

    public List<TincionCornealEnum> getListaTincionCorneal() {
        return listaTincionCorneal;
    }

    public void setListaTincionCorneal(List<TincionCornealEnum> listaTincionCorneal) {
        this.listaTincionCorneal = listaTincionCorneal;
    }

    public List<TonometroEnum> getListaTonometros() {
        return listaTonometros;
    }

    public void setListaTonometros(List<TonometroEnum> listaTonometros) {
        this.listaTonometros = listaTonometros;
    }

    public List<AcomodativoEnum> getListaAcomodativos() {
        return listaAcomodativos;
    }

    public void setListaAcomodativos(List<AcomodativoEnum> listaAcomodativos) {
        this.listaAcomodativos = listaAcomodativos;
    }

    public List<TestAcomodacionMotoraEnum> getListaTests() {
        return listaTests;
    }

    public void setListaTests(List<TestAcomodacionMotoraEnum> listaTests) {
        this.listaTests = listaTests;
    }

    public List<VisionLejanaEnum> getListaVisionLejana() {
        return listaVisionLejana;
    }

    public void setListaVisionLejana(List<VisionLejanaEnum> listaVisionLejana) {
        this.listaVisionLejana = listaVisionLejana;
    }

    public List<MusculoEnum> getListaMusculos() {
        return listaMusculos;
    }

    public void setListaMusculos(List<MusculoEnum> listaMusculos) {
        this.listaMusculos = listaMusculos;
    }

    public List<ObjetoLuzEnum> getListaObjetoLuz() {
        return listaObjetoLuz;
    }

    public void setListaObjetoLuz(List<ObjetoLuzEnum> listaObjetoLuz) {
        this.listaObjetoLuz = listaObjetoLuz;
    }

    public List<VersionEnum> getListaVersiones() {
        return listaVersiones;
    }

    public void setListaVersiones(List<VersionEnum> listaVersiones) {
        this.listaVersiones = listaVersiones;
    }

    public List<CantidadEnum> getListaCantidades() {
        return listaCantidades;
    }

    public void setListaCantidades(List<CantidadEnum> listaCantidades) {
        this.listaCantidades = listaCantidades;
    }

    public TPrescripcionMedica getPrescripcionMedica() {
        return prescripcionMedica;
    }

    public void setPrescripcionMedica(TPrescripcionMedica prescripcionMedica) {
        this.prescripcionMedica = prescripcionMedica;
    }

    public List<EquipoEnum> getListaEquipos() {
        return listaEquipos;
    }

    public void setListaEquipos(List<EquipoEnum> listaEquipos) {
        this.listaEquipos = listaEquipos;
    }

    public List<DominanteEnum> getListaDominantes() {
        return listaDominantes;
    }

    public void setListaDominantes(List<DominanteEnum> listaDominantes) {
        this.listaDominantes = listaDominantes;
    }

    public List<BrucknerEnum> getListaBruckner() {
        return listaBruckner;
    }

    public void setListaBruckner(List<BrucknerEnum> listaBruckner) {
        this.listaBruckner = listaBruckner;
    }

    public List<MedioRefractanteEnum> getListaMedioRefractante() {
        return listaMedioRefractante;
    }

    public void setListaMedioRefractante(
            List<MedioRefractanteEnum> listaMedioRefractante) {
        this.listaMedioRefractante = listaMedioRefractante;
    }

    public List<TipoGlandulaEnum> getListaTipoGlandula() {
        return listaTipoGlandula;
    }

    public void setListaTipoGlandula(List<TipoGlandulaEnum> listaTipoGlandula) {
        this.listaTipoGlandula = listaTipoGlandula;
    }

    public List<TecnicaPeliculaLagrimalEnum> getListaPeliculaLagrimal() {
        return listaPeliculaLagrimal;
    }

    public void setListaPeliculaLagrimal(
            List<TecnicaPeliculaLagrimalEnum> listaPeliculaLagrimal) {
        this.listaPeliculaLagrimal = listaPeliculaLagrimal;
    }

    public List<TecnicaPoloPosteriorEnum> getListaPoloPosterior() {
        return listaPoloPosterior;
    }

    public void setListaPoloPosterior(
            List<TecnicaPoloPosteriorEnum> listaPoloPosterior) {
        this.listaPoloPosterior = listaPoloPosterior;
    }

    public List<TecnicaTincionConjuntivalEnum> getListaTincionConjuntival() {
        return listaTincionConjuntival;
    }

    public void setListaTincionConjuntival(
            List<TecnicaTincionConjuntivalEnum> listaTincionConjuntival) {
        this.listaTincionConjuntival = listaTincionConjuntival;
    }

    public List<FiltroEnum> getListaFiltros() {
        return listaFiltros;
    }

    public void setListaFiltros(List<FiltroEnum> listaFiltros) {
        this.listaFiltros = listaFiltros;
    }

    public List<TipoRefraccionEnum> getListaTipoRefraccion() {
        return listaTipoRefraccion;
    }

    public void setListaTipoRefraccion(List<TipoRefraccionEnum> listaTipoRefraccion) {
        this.listaTipoRefraccion = listaTipoRefraccion;
    }

    public List<MiraEnum> getListaMiras() {
        return listaMiras;
    }

    public void setListaMiras(List<MiraEnum> listaMiras) {
        this.listaMiras = listaMiras;
    }

    public List<ManoDominanteEnum> getListaManoDominante() {
        return listaManoDominante;
    }

    public void setListaManoDominante(List<ManoDominanteEnum> listaManoDominante) {
        this.listaManoDominante = listaManoDominante;
    }

    public List<AnguloKappaEnum> getListaAnguloKappa() {
        return listaAnguloKappa;
    }

    public void setListaAnguloKappa(List<AnguloKappaEnum> listaAnguloKappa) {
        this.listaAnguloKappa = listaAnguloKappa;
    }

    public List<DuccionesEnum> getListaDucciones() {
        return listaDucciones;
    }

    public void setListaDucciones(List<DuccionesEnum> listaDucciones) {
        this.listaDucciones = listaDucciones;
    }

    public List<MusculoVersionesEnum> getListaMusculoVersion() {
        return listaMusculoVersion;
    }

    public void setListaMusculoVersion(
            List<MusculoVersionesEnum> listaMusculoVersion) {
        this.listaMusculoVersion = listaMusculoVersion;
    }

    public List<TTipOptotipo> getListaOptotiposVP() {
        return listaOptotiposVP;
    }

    public void setListaOptotiposVP(List<TTipOptotipo> listaOptotiposVP) {
        this.listaOptotiposVP = listaOptotiposVP;
    }

    public List<TTipOptotipo> getListaOptotiposVL() {
        return listaOptotiposVL;
    }

    public void setListaOptotiposVL(List<TTipOptotipo> listaOptotiposVL) {
        this.listaOptotiposVL = listaOptotiposVL;
    }

    public List<TipoMedicamentoEnum> getListaTipoMedicamento() {
        return listaTipoMedicamento;
    }

    public void setListaTipoMedicamento(
            List<TipoMedicamentoEnum> listaTipoMedicamento) {
        this.listaTipoMedicamento = listaTipoMedicamento;
    }

    public List<String> getListaGenericos() {
        return listaGenericos;
    }

    public void setListaGenericos(List<String> listaGenericos) {
        this.listaGenericos = listaGenericos;
    }

    public List<PresentacionEnum> getListaPresentaciones() {
        return listaPresentaciones;
    }

    public void setListaPresentaciones(List<PresentacionEnum> listaPresentaciones) {
        this.listaPresentaciones = listaPresentaciones;
    }

    public List<String> getListaNombresComerciales() {
        return listaNombresComerciales;
    }

    public void setListaNombresComerciales(List<String> listaNombresComerciales) {
        this.listaNombresComerciales = listaNombresComerciales;
    }

    public List<TMedicamento> getListaMedicamentosSelected() {
        return listaMedicamentosSelected;
    }

    public void setListaMedicamentosSelected(
            List<TMedicamento> listaMedicamentosSelected) {
        this.listaMedicamentosSelected = listaMedicamentosSelected;
    }

    public TCatalogoMedicamento getMedicamentoSearch() {
        return medicamentoSearch;
    }

    public void setMedicamentoSearch(TCatalogoMedicamento medicamentoSearch) {
        this.medicamentoSearch = medicamentoSearch;
    }

    public List<TCatalogoMedicamento> getListaMedicamentos() {
        return listaMedicamentos;
    }

    public void setListaMedicamentos(List<TCatalogoMedicamento> listaMedicamentos) {
        this.listaMedicamentos = listaMedicamentos;
    }

    public List<TCatalogoMedicamento> getListaMedicamentosResult() {
        return listaMedicamentosResult;
    }

    public void setListaMedicamentosResult(
            List<TCatalogoMedicamento> listaMedicamentosResult) {
        this.listaMedicamentosResult = listaMedicamentosResult;
    }

    public List<DistanciaPupilarEnum> getListaDistPupilar() {
        return listaDistPupilar;
    }

    public void setListaDistPupilar(List<DistanciaPupilarEnum> listaDistPupilar) {
        this.listaDistPupilar = listaDistPupilar;
    }

    public List<DistanciaNasoPupilarEnum> getListaDistNasoPupilar() {
        return listaDistNasoPupilar;
    }

    public void setListaDistNasoPupilar(
            List<DistanciaNasoPupilarEnum> listaDistNasoPupilar) {
        this.listaDistNasoPupilar = listaDistNasoPupilar;
    }

    /*public AdministrarLoginAction getAdministrarLoginAction() {
     return administrarLoginAction;
     }

     public void setAdministrarLoginAction(
     AdministrarLoginAction administrarLoginAction) {
     this.administrarLoginAction = administrarLoginAction;
     }*/
    public TPrescripcionLentesContacto getPrescripcionLentes() {
        return prescripcionLentes;
    }

    public void setPrescripcionLentes(TPrescripcionLentesContacto prescripcionLentes) {
        this.prescripcionLentes = prescripcionLentes;
    }

    public List<TipoLenteContactoEnum> getListaLentesContacto() {
        return listaLentesContacto;
    }

    public void setListaLentesContacto(
            List<TipoLenteContactoEnum> listaLentesContacto) {
        this.listaLentesContacto = listaLentesContacto;
    }

    public List<NombreComercialEnum> getListaNombreComercial() {
        return listaNombreComercial;
    }

    public void setListaNombreComercial(
            List<NombreComercialEnum> listaNombreComercial) {
        this.listaNombreComercial = listaNombreComercial;
    }

    public List<UsoLenteContactoEnum> getListaUsoLentesConstacto() {
        return listaUsoLentesConstacto;
    }

    public void setListaUsoLentesConstacto(
            List<UsoLenteContactoEnum> listaUsoLentesConstacto) {
        this.listaUsoLentesConstacto = listaUsoLentesConstacto;
    }

    public List<ReemplazoEnum> getListaReemplazo() {
        return listaReemplazo;
    }

    public void setListaReemplazo(List<ReemplazoEnum> listaReemplazo) {
        this.listaReemplazo = listaReemplazo;
    }

    public List<SistemaLimpiezaEnum> getListaSistemaLimpieza() {
        return listaSistemaLimpieza;
    }

    public void setListaSistemaLimpieza(
            List<SistemaLimpiezaEnum> listaSistemaLimpieza) {
        this.listaSistemaLimpieza = listaSistemaLimpieza;
    }

    public List<VanHerickEnum> getListaVanHerick() {
        return listaVanHerick;
    }

    public void setListaVanHerick(List<VanHerickEnum> listaVanHerick) {
        this.listaVanHerick = listaVanHerick;
    }

    public boolean getEditingOjoDerecho() {
        return editingOjoDerecho;
    }

    public void setEditingOjoDerecho(boolean editingOjoDerecho) {
        this.editingOjoDerecho = editingOjoDerecho;
    }

    public String getTituloCanvas() {
        return tituloCanvas;
    }

    public void setTituloCanvas(String tituloCanvas) {
        this.tituloCanvas = tituloCanvas;
    }

    public int getSelectedTab() {
        return selectedTab;
    }

    public void setSelectedTab(int selectedTab) {
        this.selectedTab = selectedTab;
    }

}
